package com.toncen.samepms.system.action;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import ognl.Ognl;
import ognl.OgnlContext;

import com.toncen.samepms.basic.dao.NotificationDao;
import com.toncen.samepms.basic.domain.Notification;
import com.toncen.samepms.common.AbstractDatabaseAction;
import com.toncen.samepms.system.dao.FaqDao;
import com.toncen.samepms.system.dao.ModuleDao;
import com.toncen.samepms.system.domain.Faq;
import com.toncen.samepms.system.domain.Module;
import com.opensymphony.xwork2.ActionContext;
import com.sky.common.ognl.OgnlUtils;
import com.sky.common.sql.JavaSQLUtils;
import com.sky.common.string.StringUtils;
import com.sky.fisher.model.GridModel;
import com.sky.fisher.service.FisherService;

/**
 * 描述：桌面的action文件
 * 
 * @author tch
 * 
 */
public class DesktopAction extends AbstractDatabaseAction<Module, ModuleDao> {
	/**
	 * 序列号
	 */
	private static final long serialVersionUID = 1331283566492L;

	/**
	 * 待办事项结果集:桌面统计组以及每个分组中待办事项和数量
	 */
	private Map<Integer, List<Map<Module, Integer>>> todos = new HashMap<Integer, List<Map<Module, Integer>>>();

	/**
	 * 常见问题结果集
	 */
	private List<Faq> faqs = new ArrayList<Faq>();

	/**
	 * 内部通知结果集
	 */
	private List<Notification> notifications = new ArrayList<Notification>();

	/**
	 * 分页大小
	 */
	private int pageSize = 10;

	/**
	 * 当前页数
	 */
	private int page;

	/**
	 * @return the todos
	 */
	public Map<Integer, List<Map<Module, Integer>>> getTodos() {
		return todos;
	}

	/**
	 * @return the page
	 */
	public int getPage() {
		return page;
	}

	/**
	 * @param page
	 *            the page to set
	 */
	public void setPage(int page) {
		this.page = page;
	}

	/**
	 * @return the pageSize
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * @param pageSize
	 *            the pageSize to set
	 */
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	/**
	 * @return the faqs
	 */
	public List<Faq> getFaqs() {
		return faqs;
	}

	/**
	 * @return the notifications
	 */
	public List<Notification> getNotifications() {
		return notifications;
	}

	public DesktopAction() throws Exception {
		super();
	}

	/**
	 * 待办事项
	 * 
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public String onDoTodo() throws Exception {
		if (ActionContext.getContext().getSession().containsKey(MODULE_SESSION_ATTRIBUTE)) {
			List<Module> roots = (List<Module>) ActionContext.getContext().getSession().get(MODULE_SESSION_ATTRIBUTE);
			List<Module> allModules = new ArrayList<Module>();
			for (Module root : roots) {
				allModules.addAll(root.getAllChilds());
			}
			// 查询模块注册中注册了fishergrid配置文件名称、模块正在使用的模块
			String strSQL = " select * from " + Module.class.getName() + " where  state=1 and desktopFishergrid is not null and desktopFishergrid!=''"
					+ " order by desktopGroup,desktopSequence ";
			List<Module> desktopModules = JavaSQLUtils.execute(allModules, strSQL);
			int total;
			for (Module module : desktopModules) {
				total = computeTodo(module);
				logger.debug("模块【" + module.getName() + "】桌面统计结果【" + total + "】...");
				if (total != 0) {
					addTodo(module, total);
				}
			}
		} else {
			throw new Exception("当前会话中未找到用户权限属性【" + MODULE_SESSION_ATTRIBUTE + "】，请与系统管理员联系！");
		}
		return SUCCESS;
	}

	/**
	 * 计算待办事项
	 * 
	 * @param module
	 * @return
	 * @throws Exception
	 */
	private int computeTodo(Module module) throws Exception {
		try {
			Map<String, String[]> parameters = new HashMap<String, String[]>();
			Map<String, String> scopes = new HashMap<String, String>();// 数据过滤类型和值
			if (!StringUtils.isEmpty(module.getDesktopFilterType())// 桌面统计过滤类型有设置
					&& (!StringUtils.isEmpty(module.getDesktopQueryValue())// 桌面统计查询值有设置
							&& module.getDesktopQueryValue().indexOf(Module.SCOPE_PLACEHOLDER_START) != -1// 桌面统计查询值包含过滤类型替换符开始符号
					&& module.getDesktopQueryValue().indexOf(Module.SCOPE_PLACEHOLDER_END) != -1)// 桌面统计查询值包含过滤类型替换符结束符号
					|| (!StringUtils.isEmpty(module.getDesktopDynamicValue())// 桌面统计动态值有设置
							&& module.getDesktopDynamicValue().indexOf(Module.SCOPE_PLACEHOLDER_START) != -1// 桌面统计动态值包含过滤类型替换符开始符号
					&& module.getDesktopDynamicValue().indexOf(Module.SCOPE_PLACEHOLDER_END) != -1)) {// 桌面统计动态值包含过滤类型替换符结束符号
				String scopeType = "";// 数据过滤类型
				String scopeIds = "";// 数据过滤值
				for (String filterType : module.getDesktopFilterTypes()) {
					if (!StringUtils.isEmpty(filterType)) {
						scopeType = filterType;
						scopeIds = getPermissions(filterType, getCurrentUser());
						scopes.put(Module.SCOPE_PLACEHOLDER_START + scopeType + Module.SCOPE_PLACEHOLDER_END, scopeIds);
					}
				}
			}
			if (!StringUtils.isEmpty(module.getDesktopQueryColumn()) //
					&& !StringUtils.isEmpty(module.getDesktopQueryValue())) {// 查询字段有设置
				StringBuffer queryColumns = new StringBuffer();
				StringBuffer queryValues = new StringBuffer();
				String[] regexs = { FisherService.SEPARATOR_QUERY_AND, FisherService.SEPARATOR_QUERY_OR, FisherService.SEPARATOR_QUERY_BRACKETS_LEFT,
						FisherService.SEPARATOR_QUERY_BRACKETS_RIGHT };
				// 获取到解析的逻辑条件和对应的查询值
				String[][] columns = StringUtils.split(relaceOGNLValue(module.getDesktopQueryColumn()), regexs, FisherService.SEPARATOR_QUERY_AND);// 替换OGNL表达式
				String[][] values = StringUtils.split(relaceOGNLValue(module.getDesktopQueryValue()), regexs, FisherService.SEPARATOR_QUERY_AND);// 替换OGNL表达式
				if (columns != null && columns != null) {// 两个都存在
					if (columns.length != values.length) {
						throw new Exception("查询字段与查询值长度不匹配，请与系统管理员联系！");
					}
					for (int index = 0; columns != null && index < columns[0].length; index++) {
						// 查询字段
						queryColumns.append(columns[0][index]);
						queryColumns.append(columns[1][index]);
						// 查询条件
						queryValues.append(columns[0][index]);
						queryValues.append(replaceFilterValue(values[1][index], scopes));
					}
					parameters.put(FisherService.PARAMETER_QUERY_NAME, new String[] { queryColumns.toString() });
					parameters.put(FisherService.PARAMETER_QUERY_VALUE, new String[] { queryValues.toString() });
				}
			}
			if (!StringUtils.isEmpty(module.getDesktopDynamicColumn()) //
					&& !StringUtils.isEmpty(module.getDesktopDynamicValue())) {// 动态字段有设置
				parameters.put(FisherService.PARAMETER_DYNAMIC_NAME, new String[] { replaceFilterValue(relaceOGNLValue(module.getDesktopDynamicColumn()),// 替换OGNL表达式和过滤值
						scopes) });
				parameters.put(FisherService.PARAMETER_DYNAMIC_VALUE, new String[] { replaceFilterValue(relaceOGNLValue(module.getDesktopDynamicValue()),// 替换OGNL表达式和过滤值
						scopes) });
			}
			GridModel gridModel = FisherService.getGrid(relaceOGNLValue(module.getDesktopFishergrid()));// 替换OGNL表达式
			String strSQL = FisherService.getSQL(gridModel, parameters);
			int result = FisherService.getConnectionProvider(gridModel).getQuery().getTotalNumber(strSQL);
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("获取模块【" + module.getName() + "】桌面统计待办事项错误：" + e.getMessage(), e);
			return -1;
		}
	}

	/**
	 * 替换过滤值
	 * 
	 * @param content
	 * @param scopes
	 * @return
	 * @throws Exception
	 */
	private String replaceFilterValue(String content, Map<String, String> scopes) throws Exception {
		String result = content;
		if (!StringUtils.isEmpty(content)) {
			if (scopes.size() == 1) {// 只有一个，则使用唯一的一个过滤类型替换桌面统计过滤类型替换符默认类型
				result = StringUtils.replaceAll(result, Module.SCOPE_PLACEHOLDER_DEFAULT, scopes.values().iterator().next());
			}
			for (String scopeType : scopes.keySet()) {
				result = StringUtils.replaceAll(result, scopeType, scopes.get(scopeType));
			}
		}
		return result;
	}

	/**
	 * 替换OGNL值
	 * 
	 * @param content
	 * @return
	 * @throws Exception
	 */
	private String relaceOGNLValue(String content) throws Exception {
		String result = content;
		if (!StringUtils.isEmpty(content)) {
			Set<String> expressionSet = StringUtils.getAllTag(result, Module.OGNL_START_TAG, Module.OGNL_END_TAG);
			Object value;
			OgnlContext ognlContext = (OgnlContext) Ognl.createDefaultContext(null);
			for (String expression : expressionSet) {
				value = OgnlUtils.getValue(expression, ognlContext, this);
				result = StringUtils.replaceAll(result, Module.OGNL_START_TAG + expression + Module.OGNL_END_TAG, value.toString());
			}
		}
		return result;
	}

	/**
	 * 添加待办事项
	 * 
	 * @param module
	 * @param total
	 */
	private void addTodo(Module module, int total) {
		if (!todos.containsKey(module.getDesktopGroup())) {// 桌面统计组没有
			todos.put(module.getDesktopGroup(), new ArrayList<Map<Module, Integer>>());
		}
		Map<Module, Integer> todo = new HashMap<Module, Integer>();
		todo.put(module, total);
		todos.get(module.getDesktopGroup()).add(todo);
	}

	/**
	 * 快捷方式
	 * 
	 * @return
	 * @throws Exception
	 */
	public String onDoShortcuts() throws Exception {
		// TODO
		return SUCCESS;
	}

	/**
	 * 常用查询
	 * 
	 * @return
	 * @throws Exception
	 */
	public String onDoQuerier() throws Exception {
		// TODO
		return SUCCESS;
	}

	/**
	 * 升级记录
	 * 
	 * @return
	 * @throws Exception
	 */
	public String onDoUpgradeLog() throws Exception {
		// TODO
		return SUCCESS;
	}

	/**
	 * 常见问题
	 * 
	 * @return
	 * @throws Exception
	 */
	public String onDoFAQ() throws Exception {
		faqs = new FaqDao().getAllByState(1, pageSize, page);
		return SUCCESS;
	}

	/**
	 * 内部通知
	 * 
	 * @return
	 * @throws Exception
	 */
	public String onDoNotification() throws Exception {
		notifications = new NotificationDao().getAllByState(1, pageSize, page);
		return SUCCESS;
	}

	/**
	 * 判断是否新
	 * 
	 * @param date
	 * @return
	 * @throws Exception
	 */
	public boolean isNew(Date date) throws Exception {
		int days = 3;
		Date current = new Date();
		return (current.getTime() - date.getTime()) / (24 * 60 * 60 * 1000) <= days;
	}

	/**
	 * 获取标题
	 * 
	 * @param title
	 * @param length
	 * @return
	 */
	public String getTitle(String title, int length) {
		if (title.getBytes().length > length) {
			String index;
			int total = 0;
			for (int i = 0; i < title.length(); i++) {
				index = title.substring(i, i + 1);
				total += index.getBytes().length;
				if (total >= length) {
					return title.substring(0, i + 1) + "...";
				}
			}
		}
		return title;
	}
}
